home *** CD-ROM | disk | FTP | other *** search
/ AMIGA-CD 2 / Amiga-CD - Volume 2.iso / gepackte_disketten / 1994 / 08_94_5.dms / 08_94_5.adf / term-4.0-Source.lha / CapturePanel.c < prev    next >
C/C++ Source or Header  |  1994-06-26  |  21KB  |  840 lines
  1. /*
  2. **    CapturePanel.c
  3. **
  4. **    Editing panel for log file, buffer and capture configuration
  5. **
  6. **    Copyright © 1990-1994 by Olaf `Olsen' Barthel
  7. **        All Rights Reserved
  8. */
  9.  
  10. #include "termGlobal.h"
  11.  
  12. enum    {    GAD_LOGACTIONS, GAD_LOGFILE, GAD_SELECT_LOGFILE, GAD_LOGCALLS, GAD_CALL_LOGFILE,GAD_SELECT_CALL_LOGFILE,
  13.         GAD_MAX_BUFFER_SIZE,GAD_BUFFER_ENABLED,GAD_BUFFER_PATH,GAD_SELECT_BUFFER_PATH,
  14.         GAD_CONNECT_AUTO_CAPTURE, GAD_AUTOCAPTURE_DATE, GAD_CAPTURE_FILTER,
  15.         GAD_CAPTURE_PATH, GAD_SELECT_CAPTURE_PATH, GAD_OPEN_BUFFER_WINDOW,
  16.         GAD_REMEMBER_WINDOW_POS,GAD_OPEN_BUFFER_SCREEN,GAD_REMEMBER_SCREEN_POS,GAD_SEARCH_HISTORY,
  17.         GAD_SCREENMODE,GAD_BUFFERSCREEN_POSITION,GAD_BUFFERWIDTH,GAD_USE, GAD_CANCEL, GAD_DEFAULT };
  18.  
  19. struct ModeNode
  20. {
  21.     struct Node    VanillaNode;
  22.     ULONG        DisplayID;
  23. };
  24.  
  25. STATIC struct List    ModeList;
  26. STATIC struct List * __regargs
  27. BuildModeList(LONG *Index,ULONG DisplayMode)
  28. {
  29.     struct List    *List;
  30.     LONG         Count = 0;
  31.  
  32.     *Index = 0;
  33.  
  34.     if(List = (struct List *)AllocVecPooled(sizeof(struct List),MEMF_ANY))
  35.     {
  36.         struct DisplayInfo    DisplayInfo;
  37.         ULONG            SomeMode = INVALID_ID;
  38.  
  39.         NewList(List);
  40.  
  41.         while((SomeMode = NextDisplayInfo(SomeMode)) != INVALID_ID)
  42.         {
  43.             if(GetDisplayInfoData(NULL,(APTR)&DisplayInfo,sizeof(struct DisplayInfo),DTAG_DISP,SomeMode))
  44.             {
  45.                 if((DisplayInfo . PropertyFlags & DIPF_IS_WB) && !DisplayInfo . NotAvailable)
  46.                 {
  47.                     STRPTR Name;
  48.  
  49.                     if(Name = GetModeName(SomeMode))
  50.                     {
  51.                         struct ModeNode    *ModeNode;
  52.  
  53.                         if(ModeNode = (struct ModeNode *)AllocVecPooled(sizeof(struct ModeNode) + strlen(Name) + 1,MEMF_ANY))
  54.                         {
  55.                             ModeNode -> VanillaNode . ln_Name = (STRPTR)(ModeNode + 1);
  56.  
  57.                             strcpy(ModeNode -> VanillaNode . ln_Name,Name);
  58.  
  59.                             ModeNode -> DisplayID = SomeMode;
  60.  
  61.                             if(SomeMode == DisplayMode)
  62.                                 *Index = Count;
  63.  
  64.                             AddTail(List,ModeNode);
  65.  
  66.                             Count++;
  67.                         }
  68.                     }
  69.                 }
  70.             }
  71.         }
  72.     }
  73.  
  74.     if(Count)
  75.         return(List);
  76.     else
  77.     {
  78.         DeleteList(List);
  79.  
  80.         return(NULL);
  81.     }
  82. }
  83.  
  84. STATIC BYTE  __regargs
  85. SelectDisplayMode(struct Window *Window,ULONG *CurrentMode,struct Configuration *Config)
  86. {
  87.     BYTE Success = FALSE;
  88.  
  89.     if(!Kick30)
  90.     {
  91.         struct List    *ModeList;
  92.         LONG         Index;
  93.  
  94.         if(ModeList = BuildModeList(&Index,*CurrentMode))
  95.         {
  96.             struct LayoutHandle *Handle;
  97.  
  98.             if(Handle = LT_CreateHandleTags(Window -> WScreen,
  99.                 LH_LocaleHook,    &LocaleHook,
  100.             TAG_DONE))
  101.             {
  102.                 struct Window *LocalWindow;
  103.  
  104.                 LT_New(Handle,
  105.                     LA_Type,    VERTICAL_KIND,
  106.                 TAG_DONE);
  107.                 {
  108.                     LT_New(Handle,
  109.                         LA_Type,    VERTICAL_KIND,
  110.                     TAG_DONE);
  111.                     {
  112.                         LT_New(Handle,
  113.                             LA_Type,    LISTVIEW_KIND,
  114.                             LA_LabelID,    MSG_V36_0160,
  115.                             GTLV_Labels,    ModeList,
  116.                             LA_LONG,    &Index,
  117.                             LALV_CursorKey,    TRUE,
  118.                             LALV_Link,    NIL_LINK,
  119.                             LALV_MaxGrowY,    20,
  120.                             LA_Lines,    10,
  121.                             LA_Chars,    40,
  122.                             LA_CursorKey,    TRUE,
  123.                         TAG_DONE);
  124.  
  125.                         LT_EndGroup(Handle);
  126.                     }
  127.  
  128.                     LT_New(Handle,
  129.                         LA_Type,VERTICAL_KIND,
  130.                     TAG_DONE);
  131.                     {
  132.                         LT_New(Handle,
  133.                             LA_Type,    XBAR_KIND,
  134.                             LAXB_FullSize,    TRUE,
  135.                         TAG_DONE);
  136.  
  137.                         LT_EndGroup(Handle);
  138.                     }
  139.  
  140.                     LT_New(Handle,LA_Type,HORIZONTAL_KIND,
  141.                         LAGR_SameSize,    TRUE,
  142.                         LAGR_Spread,    TRUE,
  143.                     TAG_DONE);
  144.                     {
  145.                         LT_New(Handle,
  146.                             LA_Type,    BUTTON_KIND,
  147.                             LA_LabelID,    MSG_GLOBAL_USE_GAD,
  148.                             LA_ID,        GAD_USE,
  149.                             LABT_ReturnKey,    TRUE,
  150.                             LABT_ExtraFat,    TRUE,
  151.                         TAG_DONE);
  152.  
  153.                         LT_New(Handle,
  154.                             LA_Type,    BUTTON_KIND,
  155.                             LA_LabelID,    MSG_GLOBAL_CANCEL_GAD,
  156.                             LA_ID,        GAD_CANCEL,
  157.                             LABT_EscKey,    TRUE,
  158.                             LABT_ExtraFat,    TRUE,
  159.                         TAG_DONE);
  160.  
  161.                         LT_EndGroup(Handle);
  162.                     }
  163.  
  164.                     LT_EndGroup(Handle);
  165.                 }
  166.  
  167.                 if(LocalWindow = LT_Layout(Handle,LocaleString(MSG_V36_0161),NULL,0,0,IDCMP_CLOSEWINDOW,NULL,
  168.                     LAWN_HelpHook,        &GuideHook,
  169.                     WA_DepthGadget,        TRUE,
  170.                     WA_CloseGadget,        TRUE,
  171.                     WA_DragBar,        TRUE,
  172.                     WA_RMBTrap,        TRUE,
  173.                     WA_Activate,        TRUE,
  174.                 TAG_DONE))
  175.                 {
  176.                     struct IntuiMessage    *Message;
  177.                     BOOL             Done = FALSE;
  178.                     ULONG             MsgClass,
  179.                                  MsgQualifier;
  180.                     UWORD             MsgCode;
  181.                     struct Gadget        *MsgGadget;
  182.                     LONG             i;
  183.                     struct ModeNode        *ModeNode;
  184.  
  185.                     do
  186.                     {
  187.                         WaitPort(LocalWindow -> UserPort);
  188.  
  189.                         while(Message = (struct IntuiMessage *)GT_GetIMsg(LocalWindow -> UserPort))
  190.                         {
  191.                             MsgClass    = Message -> Class;
  192.                             MsgCode        = Message -> Code;
  193.                             MsgQualifier    = Message -> Qualifier;
  194.                             MsgGadget    = (struct Gadget *)Message -> IAddress;
  195.  
  196.                             GT_ReplyIMsg(Message);
  197.  
  198.                             LT_HandleInput(Handle,MsgQualifier,&MsgClass,&MsgCode,&MsgGadget);
  199.  
  200.                             if(MsgClass == IDCMP_CLOSEWINDOW)
  201.                                 Done = TRUE;
  202.  
  203.                             if(MsgClass == IDCMP_GADGETUP)
  204.                             {
  205.                                 switch(MsgGadget -> GadgetID)
  206.                                 {
  207.                                     case GAD_USE:
  208.  
  209.                                         for(ModeNode = (struct ModeNode *)ModeList -> lh_Head, i = 0 ; ModeNode -> VanillaNode . ln_Succ ; ModeNode = (struct ModeNode *)ModeNode -> VanillaNode . ln_Succ, i++)
  210.                                         {
  211.                                             if(Index == i)
  212.                                             {
  213.                                                 *CurrentMode = ModeNode -> DisplayID;
  214.  
  215.                                                 break;
  216.                                             }
  217.                                         }
  218.  
  219.                                         Success = Done = TRUE;
  220.                                         break;
  221.  
  222.                                     case GAD_CANCEL:
  223.  
  224.                                         Done = TRUE;
  225.                                         break;
  226.                                 }
  227.                             }
  228.  
  229.                             if(MsgClass == IDCMP_IDCMPUPDATE)
  230.                             {
  231.                                 for(ModeNode = (struct ModeNode *)ModeList -> lh_Head, i = 0; ModeNode -> VanillaNode . ln_Succ ; ModeNode = (struct ModeNode *)ModeNode -> VanillaNode . ln_Succ, i++)
  232.                                 {
  233.                                     if(Index == i)
  234.                                     {
  235.                                         *CurrentMode = ModeNode -> DisplayID;
  236.  
  237.                                         Success = Done = TRUE;
  238.  
  239.                                         LT_PressButton(Handle,GAD_USE);
  240.  
  241.                                         break;
  242.                                     }
  243.                                 }
  244.                             }
  245.                         }
  246.                     }
  247.                     while(!Done);
  248.                 }
  249.  
  250.                 LT_DeleteHandle(Handle);
  251.             }
  252.  
  253.             DeleteList(ModeList);
  254.         }
  255.     }
  256.     else
  257.     {
  258.         struct ScreenModeRequester    *Request;
  259.         LONG                 Left    = 0,
  260.                          Top    = 0,
  261.                          Width    = 0,
  262.                          Height    = 0;
  263.  
  264.         GetWindowInfo(WINDOW_SCREEN,&Left,&Top,&Width,&Height,Window -> Width / 2,Window -> Height / 2);
  265.  
  266.         if(Request = (struct ScreenModeRequester *)AllocAslRequestTags(ASL_ScreenModeRequest,
  267.             ASLSM_Window,            Window,
  268.             ASLSM_InitialDisplayID,        *CurrentMode,
  269.             ASLSM_PrivateIDCMP,        TRUE,
  270.  
  271.             ASL_LeftEdge,            Left,
  272.             ASL_TopEdge,            Top,
  273.             ASL_Width,            Width,
  274.             ASL_Height,            Height,
  275.         TAG_DONE))
  276.         {
  277.             if(AslRequestTags(Request,TAG_DONE))
  278.             {
  279.                 PutWindowInfo(WINDOW_SCREEN,Request -> sm_LeftEdge,Request -> sm_TopEdge,Request -> sm_Width,Request -> sm_Height);
  280.  
  281.                 *CurrentMode = Request -> sm_DisplayID;
  282.  
  283.                 Success = TRUE;
  284.             }
  285.  
  286.             FreeAslRequest(Request);
  287.         }
  288.     }
  289.  
  290.     return(Success);
  291. }
  292.  
  293. BYTE __regargs
  294. CapturePanel(struct Configuration *Config,BYTE *Default)
  295. {
  296.     struct LayoutHandle    *Handle;
  297.     BYTE             Cancel = FALSE;
  298.  
  299.     SaveConfig(Config,PrivateConfig);
  300.  
  301.     if(Handle = LT_CreateHandleTags(Window -> WScreen,
  302.         LH_LocaleHook,    &LocaleHook,
  303.     TAG_DONE))
  304.     {
  305.         struct Window    *Window;
  306.         BYTE         OpenBufferWindow = Config -> CaptureConfig -> OpenBufferWindow & 0xF,
  307.                  OpenBufferScreen = Config -> CaptureConfig -> OpenBufferScreen & 0xF;
  308.         UBYTE         ModeName[DISPLAYNAMELEN + 1];
  309.         ULONG         DisplayMode;
  310.  
  311.         DisplayMode = Config -> CaptureConfig -> BufferScreenMode;
  312.  
  313.         if(ModeNotAvailable(DisplayMode))
  314.             DisplayMode = Config -> ScreenConfig -> DisplayMode;
  315.  
  316.         if(ModeNotAvailable(DisplayMode))
  317.         {
  318.             struct Screen *PubScreen = LockPubScreen(NULL);
  319.  
  320.             if(PubScreen)
  321.             {
  322.                 DisplayMode = GetVPModeID(&PubScreen -> ViewPort);
  323.  
  324.                 UnlockPubScreen(NULL,PubScreen);
  325.             }
  326.             else
  327.                 DisplayMode = DEFAULT_MONITOR_ID | HIRES_KEY;
  328.         }
  329.  
  330.         strcpy(ModeName,GetModeName(DisplayMode));
  331.  
  332.         LT_New(Handle,
  333.             LA_Type,    VERTICAL_KIND,
  334.         TAG_DONE);
  335.         {
  336.             LT_New(Handle,
  337.                 LA_Type,    HORIZONTAL_KIND,
  338.             TAG_DONE);
  339.             {
  340.                 LT_New(Handle,
  341.                     LA_Type,    VERTICAL_KIND,
  342.                 TAG_DONE);
  343.                 {
  344.                     LT_New(Handle,
  345.                         LA_Type,    VERTICAL_KIND,
  346.                         LA_LabelID,    MSG_V36_0008,
  347.                     TAG_DONE);
  348.                     {
  349.                         LT_New(Handle,
  350.                             LA_LabelID,    MSG_CAPTUREPANEL_LOG_ACTIONS_GAD,
  351.                             LA_Type,    CHECKBOX_KIND,
  352.                             LA_ID,        GAD_LOGACTIONS,
  353.                             LA_BYTE,    &Config -> CaptureConfig -> LogActions,
  354.                         TAG_DONE);
  355.  
  356.                         LT_New(Handle,
  357.                             LA_LabelID,    MSG_CAPTUREPANEL_LOGFILE_GAD,
  358.                             LA_Type,    STRING_KIND,
  359.                             LA_ID,        GAD_LOGFILE,
  360.                             LA_Chars,    10,
  361.                             LA_STRPTR,    Config -> CaptureConfig -> LogFileName,
  362.                             LAST_Picker,    TRUE,
  363.                             GTST_MaxChars,    MAX_FILENAME_LENGTH - 1,
  364.                         TAG_DONE);
  365.  
  366.                         LT_New(Handle,
  367.                             LA_LabelID,    MSG_CAPTUREPANEL_LOG_CALLS_GAD,
  368.                             LA_Type,    CHECKBOX_KIND,
  369.                             LA_ID,        GAD_LOGCALLS,
  370.                             LA_BYTE,    &Config -> CaptureConfig -> LogCall,
  371.                         TAG_DONE);
  372.  
  373.                         LT_New(Handle,
  374.                             LA_LabelID,    MSG_CAPTUREPANEL_CALL_LOGFILE_GAD,
  375.                             LA_Type,    STRING_KIND,
  376.                             LA_ID,        GAD_CALL_LOGFILE,
  377.                             LA_STRPTR,    Config -> CaptureConfig -> CallLogFileName,
  378.                             LAST_Picker,    TRUE,
  379.                             GTST_MaxChars,    MAX_FILENAME_LENGTH - 1,
  380.                         TAG_DONE);
  381.  
  382.                         LT_EndGroup(Handle);
  383.                     }
  384.  
  385.                     LT_New(Handle,
  386.                         LA_Type,    VERTICAL_KIND,
  387.                         LA_LabelID,    MSG_V36_0009,
  388.                     TAG_DONE);
  389.                     {
  390.                         LT_New(Handle,
  391.                             LA_LabelID,    MSG_CAPTUREPANEL_BUFFER_ENABLED_GAD,
  392.                             LA_Type,    CHECKBOX_KIND,
  393.                             LA_ID,        GAD_BUFFER_ENABLED,
  394.                             LA_BYTE,    &Config -> CaptureConfig -> BufferEnabled,
  395.                         TAG_DONE);
  396.  
  397.                         LT_New(Handle,
  398.                             LA_LabelID,        MSG_CAPTUREPANEL_MAX_BUFFER_SIZE_GAD,
  399.                             LA_Type,        INTEGER_KIND,
  400.                             LA_ID,            GAD_MAX_BUFFER_SIZE,
  401.                             LA_LONG,        &Config -> CaptureConfig -> MaxBufferSize,
  402.                             LAIN_UseIncrementers,    TRUE,
  403.                             LAIN_Min,        0,
  404.                         TAG_DONE);
  405.  
  406.                         LT_New(Handle,
  407.                             LA_LabelID,    MSG_CAPTUREPANEL_BUFFER_PATH_GAD,
  408.                             LA_Type,    STRING_KIND,
  409.                             LA_ID,        GAD_BUFFER_PATH,
  410.                             LA_STRPTR,    Config -> CaptureConfig -> BufferPath,
  411.                             LAST_Picker,    TRUE,
  412.                             LA_Chars,    10,
  413.                             GTST_MaxChars,    MAX_FILENAME_LENGTH - 1,
  414.                         TAG_DONE);
  415.  
  416.                         LT_New(Handle,
  417.                             LA_LabelID,        MSG_CAPTUREPANEL_BUFFER_LINE_WIDTH_GAD,
  418.                             LA_Type,        SLIDER_KIND,
  419.                             LA_ID,            GAD_BUFFERWIDTH,
  420.                             LA_UBYTE,        &Config -> CaptureConfig -> BufferWidth,
  421.                             GTSL_Min,        80,
  422.                             GTSL_Max,        BUFFER_LINE_MAX,
  423.                             GTSL_LevelFormat,    "%3ld",
  424.                         TAG_DONE);
  425.  
  426.                         LT_EndGroup(Handle);
  427.                     }
  428.  
  429.                     LT_New(Handle,
  430.                         LA_Type,    VERTICAL_KIND,
  431.                         LA_LabelID,    MSG_V36_0011,
  432.                     TAG_DONE);
  433.                     {
  434.                         LT_New(Handle,
  435.                             LA_LabelID,    MSG_CAPTUREPANEL_CONNECT_AUTO_CAPTURE_GAD,
  436.                             LA_Type,    CHECKBOX_KIND,
  437.                             LA_ID,        GAD_CONNECT_AUTO_CAPTURE,
  438.                             LA_BYTE,    &Config -> CaptureConfig -> ConnectAutoCapture,
  439.                         TAG_DONE);
  440.  
  441.                         LT_New(Handle,
  442.                             LA_LabelID,    MSG_CAPTUREPANEL_CREATION_DATE_GAD,
  443.                             LA_Type,    CYCLE_KIND,
  444.                             LA_ID,        GAD_AUTOCAPTURE_DATE,
  445.                             LA_BYTE,    &Config -> CaptureConfig -> AutoCaptureDate,
  446.                             LACY_FirstLabel,MSG_CAPTUREPANEL_APPEND_DATE_TXT,
  447.                             LACY_LastLabel,    MSG_CAPTUREPANEL_WRITE_DATE_TO_FILE_TXT,
  448.                         TAG_DONE);
  449.  
  450.                         LT_New(Handle,
  451.                             LA_LabelID,    MSG_CAPTUREPANEL_CAPTURE_FILTER_ENABLED_GAD,
  452.                             LA_Type,    CHECKBOX_KIND,
  453.                             LA_ID,        GAD_CAPTURE_FILTER,
  454.                             LA_BYTE,    &Config -> CaptureConfig -> CaptureFilterMode,
  455.                         TAG_DONE);
  456.  
  457.                         LT_New(Handle,
  458.                             LA_LabelID,    MSG_CAPTUREPANEL_CAPTURE_PATH_GAD,
  459.                             LA_Type,    STRING_KIND,
  460.                             LA_ID,        GAD_CAPTURE_PATH,
  461.                             LA_Chars,    10,
  462.                             LA_STRPTR,    Config -> CaptureConfig -> CapturePath,
  463.                             LAST_Picker,    TRUE,
  464.                             GTST_MaxChars,    MAX_FILENAME_LENGTH - 1,
  465.                         TAG_DONE);
  466.  
  467.                         LT_EndGroup(Handle);
  468.                     }
  469.  
  470.                     LT_EndGroup(Handle);
  471.                 }
  472.  
  473.                 LT_New(Handle,
  474.                     LA_Type,    VERTICAL_KIND,
  475.                 TAG_DONE);
  476.                 {
  477.                     LT_New(Handle,
  478.                         LA_Type,    VERTICAL_KIND,
  479.                         LA_LabelID,    MSG_V36_0012,
  480.                     TAG_DONE);
  481.                     {
  482.                         LT_New(Handle,
  483.                             LA_Type,    VERTICAL_KIND,
  484.                             LA_LabelID,    MSG_V36_0013,
  485.                         TAG_DONE);
  486.                         {
  487.                             LT_New(Handle,
  488.                                 LA_LabelID,    MSG_CAPTUREPANEL_OPEN_BUFFER_WINDOW_GAD,
  489.                                 LA_Type,    MX_KIND,
  490.                                 LA_ID,        GAD_OPEN_BUFFER_WINDOW,
  491.                                 LA_BYTE,    &OpenBufferWindow,
  492.                                 LAMX_FirstLabel,MSG_CAPTUREPANEL_TOP_TXT,
  493.                                 LAMX_LastLabel,    MSG_CAPTUREPANEL_END_TXT,
  494.                             TAG_DONE);
  495.     
  496.                             LT_New(Handle,
  497.                                 LA_LabelID,    MSG_CAPTUREPANEL_REMEMBER_BUFFER_WINDOW_GAD,
  498.                                 LA_Type,    CHECKBOX_KIND,
  499.                                 LA_ID,        GAD_REMEMBER_WINDOW_POS,
  500.                                 LA_BYTE,    &Config -> CaptureConfig -> RememberBufferWindow,
  501.                             TAG_DONE);
  502.     
  503.                             LT_EndGroup(Handle);
  504.                         }
  505.     
  506.                         LT_New(Handle,
  507.                             LA_Type,    VERTICAL_KIND,
  508.                             LA_LabelID,    MSG_V36_0014,
  509.                         TAG_DONE);
  510.                         {
  511.                             LT_New(Handle,
  512.                                 LA_LabelID,    MSG_CAPTUREPANEL_OPEN_BUFFER_SCREEN_GAD,
  513.                                 LA_Type,    MX_KIND,
  514.                                 LA_ID,        GAD_OPEN_BUFFER_SCREEN,
  515.                                 LA_BYTE,    &OpenBufferScreen,
  516.                                 LAMX_FirstLabel,MSG_CAPTUREPANEL_TOP_TXT,
  517.                                 LAMX_LastLabel,    MSG_CAPTUREPANEL_END_TXT,
  518.                             TAG_DONE);
  519.     
  520.                             LT_New(Handle,
  521.                                 LA_LabelID,    MSG_CAPTUREPANEL_REMEMBER_BUFFER_SCREEN_GAD,
  522.                                 LA_Type,    CHECKBOX_KIND,
  523.                                 LA_ID,        GAD_REMEMBER_SCREEN_POS,
  524.                                 LA_BYTE,    &Config -> CaptureConfig -> RememberBufferScreen,
  525.                             TAG_DONE);
  526.     
  527.                             LT_New(Handle,
  528.                                 LA_LabelID,    MSG_CAPTUREPANEL_BUFFER_SCREEN_POSITION_GAD,
  529.                                 LA_Type,    MX_KIND,
  530.                                 LA_ID,        GAD_BUFFERSCREEN_POSITION,
  531.                                 LA_BYTE,    &Config -> CaptureConfig -> BufferScreenPosition,
  532.                                 LAMX_FirstLabel,MSG_CAPTUREPANEL_LEFT_TXT,
  533.                                 LAMX_LastLabel,    MSG_CAPTUREPANEL_RIGHT_TXT,
  534.                             TAG_DONE);
  535.     
  536.                             LT_New(Handle,
  537.                                 LA_Type,    TEXT_KIND,
  538.                                 LA_LabelID,    MSG_SCREENPANEL_CURRENT_DISPLAY_MODE_GAD,
  539.                                 LA_Chars,    20,
  540.                                 LA_ID,        GAD_SCREENMODE,
  541.                                 GTTX_Text,    ModeName,
  542.                                 GTTX_Border,    TRUE,
  543.                                 LATX_Picker,    TRUE,
  544.                             TAG_DONE);
  545.  
  546.                             LT_EndGroup(Handle);
  547.                         }
  548.     
  549.                         LT_New(Handle,
  550.                             LA_Type,    VERTICAL_KIND,
  551.                             LA_LabelID,    MSG_CAPTUREPANEL_SERVICES_TXT,
  552.                         TAG_DONE);
  553.                         {
  554.                             if(Config -> CaptureConfig -> SearchHistory < 1)
  555.                                 Config -> CaptureConfig -> SearchHistory = 10;
  556.  
  557.                             LT_New(Handle,
  558.                                 LA_LabelID,        MSG_CAPTUREPANEL_SEARCH_HISTORY_GAD,
  559.                                 LA_Type,        INTEGER_KIND,
  560.                                 LA_ID,            GAD_SEARCH_HISTORY,
  561.                                 LA_Chars,        8,
  562.                                 LAIN_UseIncrementers,    TRUE,
  563.                                 LAIN_Min,        1,
  564.                                 LAIN_Max,        255,
  565.                                 LA_BYTE,        &Config -> CaptureConfig -> SearchHistory,
  566.                             TAG_DONE);
  567.     
  568.                             LT_EndGroup(Handle);
  569.                         }
  570.     
  571.                         LT_EndGroup(Handle);
  572.                     }
  573.  
  574.                     LT_EndGroup(Handle);
  575.                 }
  576.  
  577.                 LT_EndGroup(Handle);
  578.             }
  579.  
  580.             LT_New(Handle,
  581.                 LA_Type,    VERTICAL_KIND,
  582.             TAG_DONE);
  583.             {
  584.                 LT_New(Handle,LA_Type,XBAR_KIND,LAXB_FullSize,TRUE,TAG_DONE);
  585.  
  586.                 LT_EndGroup(Handle);
  587.             }
  588.  
  589.             LT_New(Handle,LA_Type,HORIZONTAL_KIND,
  590.                 LAGR_SameSize,    TRUE,
  591.                 LAGR_Spread,    TRUE,
  592.             TAG_DONE);
  593.             {
  594.                 LT_New(Handle,
  595.                     LA_Type,    BUTTON_KIND,
  596.                     LA_LabelID,    MSG_GLOBAL_USE_GAD,
  597.                     LA_ID,        GAD_USE,
  598.                     LABT_ReturnKey,    TRUE,
  599.                     LABT_ExtraFat,    TRUE,
  600.                 TAG_DONE);
  601.  
  602.                 if(Default)
  603.                 {
  604.                     LT_New(Handle,
  605.                         LA_Type,    BUTTON_KIND,
  606.                         LA_LabelID,    MSG_GLOBAL_DEFAULT_GAD,
  607.                         LA_ID,        GAD_DEFAULT,
  608.                         LABT_ExtraFat,    TRUE,
  609.                     TAG_DONE);
  610.                 }
  611.  
  612.                 LT_New(Handle,
  613.                     LA_Type,    BUTTON_KIND,
  614.                     LA_LabelID,    MSG_GLOBAL_CANCEL_GAD,
  615.                     LA_ID,        GAD_CANCEL,
  616.                     LABT_EscKey,    TRUE,
  617.                     LABT_ExtraFat,    TRUE,
  618.                 TAG_DONE);
  619.  
  620.                 LT_EndGroup(Handle);
  621.             }
  622.  
  623.             LT_EndGroup(Handle);
  624.         }
  625.  
  626.         if(Window = LT_Layout(Handle,LocaleString(MSG_CAPTUREPANEL_CAPTURE_SETTINGS_TXT),NULL,0,0,IDCMP_CLOSEWINDOW,0,
  627.             LAWN_HelpHook,        &GuideHook,
  628.             WA_DepthGadget,        TRUE,
  629.             WA_CloseGadget,        TRUE,
  630.             WA_DragBar,        TRUE,
  631.             WA_RMBTrap,        TRUE,
  632.             WA_Activate,        TRUE,
  633.         TAG_DONE))
  634.         {
  635.             struct IntuiMessage    *Message;
  636.             BOOLEAN             Done = FALSE;
  637.             ULONG             MsgClass,
  638.                          MsgQualifier;
  639.             UWORD             MsgCode;
  640.             struct Gadget        *MsgGadget;
  641.             UBYTE             DummyBuffer[MAX_FILENAME_LENGTH],
  642.                         *DummyChar;
  643.             struct FileRequester    *FileRequest;
  644.  
  645.             GuideContext(CONTEXT_CAPTURE);
  646.  
  647.             PushWindow(Window);
  648.  
  649.             LT_ShowWindow(Handle,TRUE);
  650.  
  651.             do
  652.             {
  653.                 if(Wait(PORTMASK(Window -> UserPort) | SIG_BREAK) & SIG_BREAK)
  654.                 {
  655.                     SaveConfig(PrivateConfig,Config);
  656.  
  657.                     break;
  658.                 }
  659.  
  660.                 while(Message = (struct IntuiMessage *)GT_GetIMsg(Window -> UserPort))
  661.                 {
  662.                     MsgClass    = Message -> Class;
  663.                     MsgQualifier    = Message -> Qualifier;
  664.                     MsgCode        = Message -> Code;
  665.                     MsgGadget    = (struct Gadget *)Message -> IAddress;
  666.  
  667.                     GT_ReplyIMsg(Message);
  668.  
  669.                     LT_HandleInput(Handle,MsgQualifier,&MsgClass,&MsgCode,&MsgGadget);
  670.  
  671.                     if(MsgClass == IDCMP_CLOSEWINDOW)
  672.                     {
  673.                         SaveConfig(PrivateConfig,Config);
  674.  
  675.                         Done = TRUE;
  676.                     }
  677.  
  678.                     if(MsgClass == IDCMP_GADGETUP)
  679.                     {
  680.                         switch(MsgGadget -> GadgetID)
  681.                         {
  682.                             case GAD_USE:
  683.  
  684.                                 Config -> CaptureConfig -> OpenBufferWindow = OpenBufferWindow;
  685.                                 Config -> CaptureConfig -> OpenBufferScreen = OpenBufferScreen;
  686.                                 Config -> CaptureConfig -> BufferScreenMode = DisplayMode;
  687.  
  688.                                 Done = TRUE;
  689.                                 break;
  690.  
  691.                             case GAD_CANCEL:
  692.  
  693.                                 SaveConfig(PrivateConfig,Config);
  694.  
  695.                                 Cancel = Done = TRUE;
  696.                                 break;
  697.  
  698.                             case GAD_DEFAULT:
  699.  
  700.                                 *Default = TRUE;
  701.  
  702.                                 Done = TRUE;
  703.                                 break;
  704.                         }
  705.                     }
  706.  
  707.                     if(MsgClass == IDCMP_IDCMPUPDATE)
  708.                     {
  709.                         switch(MsgGadget -> GadgetID)
  710.                         {
  711.                             case GAD_LOGFILE:
  712.  
  713.                                 LT_LockWindow(Window);
  714.  
  715.                                 strcpy(DummyBuffer,(STRPTR)LT_GetAttributes(Handle,MsgGadget -> GadgetID,TAG_DONE));
  716.  
  717.                                 if(DummyBuffer[0])
  718.                                 {
  719.                                     if(FilePart(DummyBuffer) == DummyBuffer)
  720.                                         DummyBuffer[0] = 0;
  721.                                     else
  722.                                     {
  723.                                         DummyChar = PathPart(DummyBuffer);
  724.  
  725.                                         *DummyChar = 0;
  726.                                     }
  727.  
  728.                                     DummyChar = FilePart((STRPTR)LT_GetAttributes(Handle,MsgGadget -> GadgetID,TAG_DONE));
  729.                                 }
  730.                                 else
  731.                                     DummyChar = "";
  732.  
  733.                                 if(FileRequest = GetFile(Window,LocaleString(MSG_CAPTUREPANEL_SELECT_LOGFILE_TXT),DummyBuffer,DummyChar,DummyBuffer,NULL,FALSE,FALSE,FALSE,LocaleString(MSG_GLOBAL_SELECT_TXT),TRUE))
  734.                                 {
  735.                                     LT_SetAttributes(Handle,MsgGadget -> GadgetID,GTST_String,DummyBuffer,TAG_DONE);
  736.  
  737.                                     FreeAslRequest(FileRequest);
  738.                                 }
  739.  
  740.                                 LT_UnlockWindow(Window);
  741.                                 break;
  742.  
  743.                             case GAD_CALL_LOGFILE:
  744.  
  745.                                 LT_LockWindow(Window);
  746.  
  747.                                 strcpy(DummyBuffer,(STRPTR)LT_GetAttributes(Handle,MsgGadget -> GadgetID,TAG_DONE));
  748.  
  749.                                 if(DummyBuffer[0])
  750.                                 {
  751.                                     if(FilePart(DummyBuffer) == DummyBuffer)
  752.                                         DummyBuffer[0] = 0;
  753.                                     else
  754.                                     {
  755.                                         DummyChar = PathPart(DummyBuffer);
  756.  
  757.                                         *DummyChar = 0;
  758.                                     }
  759.  
  760.                                     DummyChar = FilePart((STRPTR)LT_GetAttributes(Handle,MsgGadget -> GadgetID,TAG_DONE));
  761.                                 }
  762.                                 else
  763.                                     DummyChar = "";
  764.  
  765.                                 if(FileRequest = GetFile(Window,LocaleString(MSG_CAPTUREPANEL_SELECT_CALL_LOGFILE_TXT),DummyBuffer,DummyChar,DummyBuffer,NULL,FALSE,FALSE,FALSE,LocaleString(MSG_GLOBAL_SELECT_TXT),TRUE))
  766.                                 {
  767.                                     LT_SetAttributes(Handle,MsgGadget -> GadgetID,GTST_String,DummyBuffer,TAG_DONE);
  768.  
  769.                                     FreeAslRequest(FileRequest);
  770.                                 }
  771.  
  772.                                 LT_UnlockWindow(Window);
  773.                                 break;
  774.  
  775.                             case GAD_BUFFER_PATH:
  776.  
  777.                                 LT_LockWindow(Window);
  778.  
  779.                                 strcpy(DummyBuffer,(STRPTR)LT_GetAttributes(Handle,MsgGadget -> GadgetID,TAG_DONE));
  780.  
  781.                                 if(FileRequest = GetFile(Window,LocaleString(MSG_CAPTUREPANEL_SELECT_BUFFER_PATH_TXT),DummyBuffer,"",DummyBuffer,NULL,FALSE,FALSE,TRUE,LocaleString(MSG_GLOBAL_SELECT_TXT),TRUE))
  782.                                 {
  783.                                     LT_SetAttributes(Handle,MsgGadget -> GadgetID,GTST_String,DummyBuffer,TAG_DONE);
  784.  
  785.                                     FreeAslRequest(FileRequest);
  786.                                 }
  787.  
  788.                                 LT_UnlockWindow(Window);
  789.                                 break;
  790.  
  791.                             case GAD_CAPTURE_PATH:
  792.  
  793.                                 LT_LockWindow(Window);
  794.  
  795.                                 strcpy(DummyBuffer,(STRPTR)LT_GetAttributes(Handle,MsgGadget -> GadgetID,TAG_DONE));
  796.  
  797.                                 if(FileRequest = GetFile(Window,LocaleString(MSG_CAPTUREPANEL_SELECT_CAPTURE_PATH_TXT),DummyBuffer,"",DummyBuffer,NULL,FALSE,FALSE,TRUE,LocaleString(MSG_GLOBAL_SELECT_TXT),TRUE))
  798.                                 {
  799.                                     LT_SetAttributes(Handle,MsgGadget -> GadgetID,GTST_String,DummyBuffer,TAG_DONE);
  800.  
  801.                                     FreeAslRequest(FileRequest);
  802.                                 }
  803.  
  804.                                 LT_UnlockWindow(Window);
  805.                                 break;
  806.  
  807.                             case GAD_SCREENMODE:
  808.  
  809.                                 LT_LockWindow(Window);
  810.  
  811.                                 if(SelectDisplayMode(Window,&DisplayMode,Config))
  812.                                 {
  813.                                     strcpy(ModeName,GetModeName(DisplayMode));
  814.  
  815.                                     LT_SetAttributes(Handle,GAD_SCREENMODE,GTTX_Text,ModeName,TAG_DONE);
  816.                                 }
  817.  
  818.                                 LT_UnlockWindow(Window);
  819.  
  820.                                 LT_ShowWindow(Handle,TRUE);
  821.  
  822.                                 break;
  823.                         }
  824.                     }
  825.                 }
  826.             }
  827.             while(!Done);
  828.  
  829.             PopWindow();
  830.         }
  831.  
  832.         LT_DeleteHandle(Handle);
  833.     }
  834.  
  835.     if(Default)
  836.         return((BYTE)(!Cancel));
  837.     else
  838.         return((BYTE)memcmp(PrivateConfig -> CaptureConfig,Config -> CaptureConfig,sizeof(struct CaptureSettings)));
  839. }
  840.